# 1. 创建列表
empty_list = []                      # 空列表
numbers = [1, 2, 3, 4, 5]           # 数字列表
fruits = ['apple', 'banana', '橙子'] # 混合类型
mixed = [1, 'hello', 3.14, True]     # 任意类型混合
matrix = [[1, 2], [3, 4]]           # 嵌套列表（二维）

print(fruits)  # 输出: ['apple', 'banana', '橙子']

# 2. 列表索引（从0开始）
print(fruits[0])    # 'apple'（正向索引）
print(fruits[-1])   # '橙子'（负索引表示倒数）

# 3. 列表切片 [start:end:step]
print(numbers[1:3])    # [2, 3]（不包含结束索引）
print(numbers[::2])    # [1, 3, 5]（步长2）
print(numbers[::-1])   # [5, 4, 3, 2, 1]（反转列表）



fruits[1] = 'pear'  # 修改第二个元素
print(fruits)       # ['apple', 'pear', '橙子']








fruits.append('grape')      # 末尾添加
fruits.insert(1, 'kiwi')    # 在索引1处插入
print(fruits)  # ['apple', 'kiwi', 'pear', '橙子', 'grape']
















del fruits[0]           # 删除索引0的元素
fruits.remove('pear')   # 删除第一个匹配项
popped = fruits.pop()   # 删除并返回最后一个元素
print(f"删除的元素: {popped}, 剩余列表: {fruits}")
# 输出: 删除的元素: grape, 剩余列表: ['kiwi', '橙子']













nums = [3, 1, 4, 2]
nums.sort()                     # 升序排序（原地修改）
print(nums)                     # [1, 2, 3, 4]

nums.reverse()                  # 反转列表
print(nums)                     # [4, 3, 2, 1]

# 不修改原列表的排序
sorted_nums = sorted(nums, reverse=True)  # 降序
print(sorted_nums)              # [4, 3, 2, 1]










letters = ['a', 'b', 'c', 'a', 'b']
print(letters.index('c'))       # 2（首次出现的索引）
print(letters.count('a'))       # 2（出现次数）
print('d' in letters)           # False（成员检查）











list1 = [1, 2]
list2 = [3, 4]
combined = list1 + list2        # 新建合并列表
print(combined)                 # [1, 2, 3, 4]

list1.extend(list2)             # 原地扩展list1
print(list1)                    # [1, 2, 3, 4]

# 复制列表（注意深浅拷贝区别）
shallow_copy = list1.copy()     # 浅拷贝
deep_copy = list1[:]            # 另一种浅拷贝方式











# 创建平方数列表
squares = [x**2 for x in range(5)]
print(squares)  # [0, 1, 4, 9, 16]

# 带条件的推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

# 嵌套列表推导式（矩阵转置）
matrix = [[1, 2], [3, 4], [5, 6]]
transposed = [[row[i] for row in matrix] for i in range(2)]
print(transposed)  # [[1, 3, 5], [2, 4, 6]]











students = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]

# 使用zip组合遍历
for name, score in zip(students, scores):
    print(f"{name}: {score}分")

# 找最高分学生f
max_score = max(scores)
top_student = students[scores.index(max_score)]
print(f"最高分: {top_student}({max_score}分)")

















duplicates = [1, 2, 2, 3, 4, 4, 5]
unique = list(set(duplicates))  # 利用集合去重
print(unique)  # [1, 2, 3, 4, 5]

# 保留原始顺序的去重方法
from collections import OrderedDict
unique_ordered = list(OrderedDict.fromkeys(duplicates))
print(unique_ordered)  # [1, 2, 3, 4, 5]






# 学生成绩管理系统
class GradeManager:
    def __init__(self):
        self.students = []  # 存储学生姓名
        self.scores = []  # 存储对应成绩

    def add_student(self, name, score):
        """添加学生及其成绩"""
        if name in self.students:
            print(f"【警告】{name} 已存在！")
        else:
            self.students.append(name)
            self.scores.append(score)
            print(f"成功添加：{name} - {score}分")

    def delete_student(self, name):
        """删除学生记录"""
        if name in self.students:
            index = self.students.index(name)
            self.students.pop(index)
            score = self.scores.pop(index)
            print(f"已删除：{name}（原成绩：{score}分）")
        else:
            print(f"【错误】找不到学生：{name}")

    def show_average(self):
        """计算并显示平均分"""
        if not self.scores:
            print("暂无成绩数据！")
        else:
            avg = sum(self.scores) / len(self.scores)
            print(f"当前平均分：{avg:.2f}（共{len(self.scores)}人）")

    def display_all(self):
        """显示所有学生成绩"""
        print("\n===== 成绩单 =====")
        for name, score in zip(self.students, self.scores):
            print(f"{name}: {score}分")
        self.show_average()


# 使用示例
manager = GradeManager()
manager.add_student("张三", 85)
manager.add_student("李四", 92)
manager.add_student("王五", 78)

manager.display_all()
"""
===== 成绩单 =====
张三: 85分
李四: 92分
王五: 78分
当前平均分：85.00（共3人）
"""

manager.delete_student("李四")
manager.add_student("赵六", 88)
manager.show_average()  # 当前平均分：83.67（共3人）

















original = [3, 2, 2, 1, 5, 1, 4]
unique = list(set(original))
print(unique)  # 可能输出：[1, 2, 3, 4, 5]（顺序随机）



unique = list(dict.fromkeys(original))
print(unique)  # [3, 2, 1, 5, 4]（保留首次出现顺序）



unique = []
[unique.append(x) for x in original if x not in unique]
print(unique)  # [3, 2, 1, 5, 4]




from collections import OrderedDict
unique = list(OrderedDict.fromkeys(original))
print(unique)  # [3, 2, 1, 5, 4]



unique = []
for item in original:
    if item not in unique:
        unique.append(item)
print(unique)  # [3, 2, 1, 5, 4]


class AdvancedGradeManager(GradeManager):
    def remove_duplicates(self):
        """去除重复成绩的学生（保留第一个）"""
        seen = set()
        i = 0
        while i < len(self.students):
            if self.scores[i] in seen:
                print(f"移除重复成绩学生：{self.students[i]}（成绩：{self.scores[i]}）")
                self.students.pop(i)
                self.scores.pop(i)
            else:
                seen.add(self.scores[i])
                i += 1

# 测试
advanced_mgr = AdvancedGradeManager()
advanced_mgr.add_student("Alice", 90)
advanced_mgr.add_student("Bob", 85)
advanced_mgr.add_student("Charlie", 90)  # 重复成绩
advanced_mgr.add_student("David", 85)    # 重复成绩

advanced_mgr.remove_duplicates()
"""
移除重复成绩学生：Charlie（成绩：90）
移除重复成绩学生：David（成绩：85）
"""
advanced_mgr.display_all()
"""
===== 成绩单 =====
Alice: 90分
Bob: 85分
当前平均分：87.50（共2人）
"""


